home *** CD-ROM | disk | FTP | other *** search
/ Turnbull China Bikeride / Turnbull China Bikeride - Disc 2.iso / ACORNUSERS / EMULATOR / MAGICKIT / assembler / c / command < prev    next >
Text File  |  1998-04-14  |  6KB  |  391 lines
  1. #include <stdio.h>
  2. #include <ctype.h>
  3. #include <string.h>
  4. #include "defs.h"
  5. #include "externs.h"
  6.  
  7. char filename[128];
  8.  
  9. /* pseudo operations processor */
  10.  
  11. pseudo(int *ip)
  12. {
  13.     switch(opval) {
  14.     case 0:                /*  .db */
  15.         do_db(ip);
  16.         break;
  17.     case 1:                /*  .dw */
  18.         do_dw(ip);
  19.         break;
  20.     case 2:                /*  .equ / = */
  21.         do_assign(ip);
  22.         break;
  23.     case 3:                /*  .page */
  24.         do_page(ip);
  25.         break;
  26.     case 4:                /*  .org */
  27.         do_org(ip);
  28.         break;
  29.     case 5:                /*  .bank */
  30.         do_bank(ip);
  31.         break;
  32.     case 6:                /*  .incbin */
  33.         do_incbin(ip);
  34.         break;
  35.     case 7:                /*  .include */
  36.         do_include(ip);
  37.         break;
  38.     case 8:                /*  .incchr/spr/pal */
  39.     case 9:
  40.     case 10:
  41.         do_pcx(ip);
  42.         break;
  43.     case 11:            /*  .macro */
  44.         do_macro(ip);
  45.         break;
  46.     case 12:            /*  .endm */
  47.         do_endm(ip);
  48.         break;
  49.     case 13:            /*  .list */
  50.         check_eol(ip);
  51.         clist = 1;
  52.         xlist = 1;
  53.         break;
  54.     case 14:            /*  .mlist */
  55.         check_eol(ip);
  56.         mlist = 1;
  57.         break;
  58.     case 15:            /*  .nolist */
  59.         check_eol(ip);
  60.         clist = 0;
  61.         break;
  62.     case 16:            /*  .nomlist */
  63.         check_eol(ip);
  64.         mlist = 0;
  65.         break;
  66.     case 17:            /*  .rsset */
  67.         do_rsset(ip);
  68.         break;
  69.     case 18:            /*  .rs */
  70.         do_rs(ip);
  71.         break;
  72.     }
  73. }
  74.  
  75. /* .db pseudo */
  76.  
  77. do_db(int *ip)
  78. {
  79.     char c;
  80.     int    count;
  81.     int    i;
  82.     int    tvalue;
  83.  
  84.     labldef(loccnt, 1);
  85.     loadlc(loccnt, 0);
  86.     while (isspace(prlnbuf[++(*ip)]));    /*    field    */
  87.     count = 0;
  88.     do {
  89.         if (prlnbuf[*ip] == '"') {
  90.             while ((tvalue = prlnbuf[++(*ip)]) != '"') {
  91.                 if (tvalue == 0) {
  92.                     error("Unterminated ASCII string!");
  93.                     return;
  94.                 }
  95.                 if (tvalue == '\\')
  96.                     switch(tvalue = prlnbuf[++(*ip)]) {
  97.                     case 'r':
  98.                         tvalue = '\r';
  99.                         break;
  100.                     case 'n':
  101.                         tvalue = '\n';
  102.                         break;
  103.                     case 't':
  104.                         tvalue = '\t';
  105.                         break;
  106.                     }
  107.                 loccnt++;
  108.                 if (pass == LAST_PASS) {
  109.                     loadv(loccnt-1, tvalue, count);
  110.                     if (++count >= 3) {
  111.                         println();
  112.                         clearln();
  113.                         count = 0;
  114.                         loadlc(loccnt, 0);
  115.                     }
  116.                 }
  117.             }
  118.             ++(*ip);
  119.         }
  120.         else {
  121.             if (!evaluate(ip, 0)) {
  122.                 loccnt++;
  123.                 return;
  124.             }
  125.             loccnt++;
  126.             if (value > 0xFF) {
  127.                 error("Operand field size error!");
  128.                 return;
  129.             }
  130.             else if (pass == LAST_PASS) {
  131.                 loadv(loccnt-1, value, count);
  132.                 if (++count >= 3) {
  133.                     println();
  134.                     clearln();
  135.                     count = 0;
  136.                     loadlc(loccnt, 0);
  137.                 }
  138.             }
  139.         }
  140.     } while ((c = prlnbuf[(*ip)++]) == ',');
  141.     if (c != ';' && c != '\0')
  142.         error("Syntax error!");
  143.     if ((pass == LAST_PASS) && (count != 0))
  144.         println();
  145. }
  146.  
  147. /* .dw pseudo */
  148.  
  149. do_dw(int *ip)
  150. {
  151.     char c;
  152.     int    i;
  153.  
  154.     labldef(loccnt, 1);
  155.     loadlc(loccnt, 0);
  156.     do {
  157.         if (!evaluate(ip, 0)) {
  158.             loccnt += 2;
  159.             return;
  160.         }
  161.         loccnt += 2;
  162.         if (pass == LAST_PASS) {
  163.             loadv(loccnt-2, value, 0, 1);
  164.             loadv(loccnt-1, value>>8, 1, 1);
  165.             println();
  166.             clearln();
  167.             loadlc(loccnt, 0);
  168.         }
  169.     } while ((c = prlnbuf[(*ip)++]) == ',');
  170.     if (c != ';' && c != '\0')
  171.         error("Syntax error!");
  172. }
  173.  
  174. /* = pseudo */
  175.  
  176. do_assign(int *ip)
  177. {
  178.     if (!evaluate(ip, ';'))
  179.         return;
  180.     labldef(value, 0);
  181.     if (pass == LAST_PASS) {
  182.         loadlc(value, 1);
  183.         println();
  184.     }
  185. }
  186.  
  187. /* .page pseudo */
  188.  
  189. do_page(int *ip)
  190. {
  191.     labldef(loccnt, 1);
  192.     if (!evaluate(ip, ';'))
  193.         return;
  194.     if (value < 0) {
  195.         error("Page index out of range!");
  196.         return;
  197.     } else if (value < 8) {
  198.         page = value;
  199.     } else {
  200.         if (value & 0x7FFF1FF8) {
  201.             error("Invalid page address!");
  202.             return;
  203.         }
  204.         page = value >> 13;
  205.     }
  206.     if (pass == LAST_PASS) {
  207.         loadlc(page << 13, 1);
  208.         println();
  209.     }
  210. }
  211.  
  212. /* .org pseudo */
  213.  
  214. do_org(int *ip)
  215. {
  216.     if (!evaluate(ip, ';'))
  217.         return;
  218.     if (undef != 0) {
  219.         error("Undefined symbol in operand field!");
  220.         return;
  221.     }
  222.     if (value & 0xFFFF0000) {
  223.         error("Address out of range!");
  224.         return;
  225.     }
  226.     page   = (value >> 13) & 0x07;
  227.     value &= 0x1FFF;
  228.     loccnt = value;
  229.     labldef(value, 1);
  230.     if (pass == LAST_PASS) {
  231.         loadlc(loccnt | (page << 13), 1);
  232.         println();
  233.     }
  234. }
  235.  
  236. /* .bank pseudo */
  237.  
  238. do_bank(int *ip)
  239. {
  240.     labldef(loccnt, 1);
  241.     if (!evaluate(ip, ';'))
  242.         return;
  243.     if ((value < 0) || (value > 127)) {
  244.         error("Bank index out of range!");
  245.         return;
  246.     }
  247.     bank_offset[bank] = loccnt;
  248.     bank_page[bank] = page;
  249.     bank = value;
  250.     page = bank_page[bank];
  251.     loccnt = bank_offset[bank];
  252.     glablptr = NULL;
  253.     if (pass == LAST_PASS) {
  254.         loadlc(bank, 1);
  255.         println();
  256.     }
  257. }
  258.  
  259. /* .incbin pseudo */
  260.  
  261. do_incbin(int *ip)
  262. {
  263.     FILE *f;
  264.     int size;
  265.     int i;
  266.  
  267.     labldef(loccnt, 1);
  268.     if (!get_filename(ip))
  269.         return;
  270.     if ((f = fopen(filename, "rb")) == NULL) {
  271.         error("Can not open file!");
  272.         return;
  273.     }
  274.     fseek(f, 0, SEEK_END);
  275.     size = ftell(f);
  276.     fseek(f, 0, SEEK_SET);
  277.     if (((bank << 13) + loccnt + size) > (8192 * 128)) {
  278.         fclose(f);
  279.         error("File too big!");
  280.         return;
  281.     }
  282.     if (pass == LAST_PASS) {
  283.         fread(&rom[bank][loccnt], 1, size, f);
  284.         loadlc(loccnt, 0);
  285.         println();
  286.     }
  287.     fclose(f);
  288.     bank  += (loccnt + size) >> 13;
  289.     loccnt = (loccnt + size) & 0x1FFF;
  290.     if (bank > max_bank) {
  291.         if (loccnt)
  292.             max_bank = bank;
  293.         else
  294.             max_bank = bank - 1;
  295.     }
  296. }
  297.  
  298. /* .include pseudo */
  299.  
  300. do_include(int *ip)
  301. {
  302.     labldef(loccnt, 1);
  303.     if (!get_filename(ip))
  304.         return;
  305.     if (pass == LAST_PASS)
  306.         println();
  307.     if (open_input(filename) == -1) {
  308.         error("Can not open file!");
  309.         return;
  310.     }
  311. }
  312.  
  313. /* .rsset pseudo */
  314.  
  315. do_rsset(int *ip)
  316. {
  317.     labldef(loccnt, 1);
  318.     if (!evaluate(ip, ';'))
  319.         return;
  320.     if (value & 0xFFFF0000) {
  321.         error("Address out of range!");
  322.         return;
  323.     }
  324.     rsbase = value;
  325.     if (pass == LAST_PASS) {
  326.         loadlc(rsbase, 1);
  327.         println();
  328.     }
  329. }
  330.  
  331. /* .rs pseudo */
  332.  
  333. do_rs(int *ip)
  334. {
  335.     labldef(rsbase, 0);
  336.     if (!evaluate(ip, ';'))
  337.         return;
  338.     if (value & 0xFFFFFF00) {
  339.         error("Size out of range!");
  340.         return;
  341.     }
  342.     if (pass == LAST_PASS) {
  343.         loadlc(rsbase, 1);
  344.         println();
  345.     }
  346.     rsbase += value;
  347. }
  348.  
  349. /* get a file name from prlnbuf */
  350.  
  351. get_filename(int *ip)
  352. {
  353.     char c;
  354.     int i;
  355.     char conv[128];
  356.     char *p, *q;
  357.  
  358.     while (isspace(prlnbuf[++(*ip)]));
  359.     if (prlnbuf[(*ip)++] != '\"') {
  360.         error("Invalid file name!");
  361.         return (0);
  362.     }
  363.     i = 0;
  364.     while (((c = prlnbuf[(*ip)++]) != '\"') && (i < 128))
  365.         filename[i++] = c;
  366.     if ((i == 128) || (i == 0)) {
  367.         error("Invalid file name!");
  368.         return (0);
  369.     }
  370.     filename[i] = '\0';
  371.  
  372.         if (!(p = strrchr(filename, '.'))) return(1);
  373.         *(p++) = '\0';
  374.         q = strrchr(filename, '.');
  375.         if (!q) q = strrchr(filename, ':');
  376.         if (q) {
  377.             q++;
  378.             strncpy(conv, filename, q - filename);
  379.             strcat(conv, p);
  380.             strcat(conv, q);
  381.         } else {
  382.             strcpy(conv, p);
  383.             strcat(conv, ".");
  384.             strcat(conv, filename);
  385.         }
  386.         strcpy(filename, conv);
  387.  
  388.     return (1);
  389. }
  390.  
  391.